// 用户认证模块API接口

/**
 * 认证模块API
 * @param {Object} config - API配置信息
 * @returns {Object} - 认证相关API方法集合
 */
module.exports = function(config) {
  // 获取认证相关的API路径
  const authPaths = config.paths.auth;
  
  // 添加重试配置
  const MAX_RETRIES = 3;  // 最大重试次数
  const RETRY_DELAY = 1000;  // 重试延迟时间（毫秒）
  
  return {
    /**
     * 微信登录
     * @param {string} code - 微信临时登录凭证
     * @param {string} encryptedData - 加密数据(可选)
     * @param {string} iv - 加密向量(可选)
     * @returns {Promise} - 登录结果
     */
    wxLogin: (code, encryptedData, iv) => {
      return new Promise((resolve, reject) => {
        // 构建请求数据
        const requestData = { code };
        
        // 添加加密数据和IV（如果有）
        if (encryptedData && iv) {
          Object.assign(requestData, { encryptedData, iv });
        }
        
        // 尝试使用标准路径登录（带重试逻辑）
        tryLoginWithRetry(0);
        
        /**
         * 使用重试逻辑尝试登录
         * @param {number} retryCount - 当前重试次数
         */
        function tryLoginWithRetry(retryCount) {
          const loginUrl = config.getFullUrl(authPaths.wxLogin);
          console.log(`开始微信登录请求 (尝试 ${retryCount+1}/${MAX_RETRIES+1})， URL:`, loginUrl);
          console.log('请求数据:', requestData);
          
          wx.request({
            url: loginUrl,
            method: 'POST',
            data: requestData,
            success: (res) => {
              console.log('微信登录响应:', res);
              
              // 处理不同状态码
              if (res.statusCode === 200) {
                if (res.data.code === 200) {
                  // 确保返回的数据包含用户ID
                  if (!res.data.data) {
                    console.error('服务器返回数据格式错误:', res.data);
                    reject({
                      code: 500,
                      message: '服务器返回数据格式错误'
                    });
                    return;
                  }

                  // 检查用户ID是否存在
                  const userId = res.data.data.userId || res.data.data.id;
                  if (!userId) {
                    console.error('服务器返回数据缺少用户ID:', res.data);
                    reject({
                      code: 500,
                      message: '服务器返回数据缺少用户ID'
                    });
                    return;
                  }
                  
                  // 确保返回的数据格式正确
                  const loginData = {
                    token: res.data.data.token,
                    refreshToken: res.data.data.refreshToken,
                    expiresIn: res.data.data.expiresIn,
                    userId: userId,
                    id: userId,
                    isNewUser: res.data.data.isNewUser || false
                  };
                  
                  console.log('处理后的登录数据:', loginData);
                  resolve(loginData);
                } else {
                  console.error('登录失败:', res.data);
                  reject({
                    code: res.data.code,
                    message: res.data.message || '登录失败，请稍后再试'
                  });
                }
              } else {
                console.error('服务器响应错误:', res.statusCode);
                reject({
                  code: res.statusCode,
                  message: '服务器响应错误'
                });
              }
            },
            fail: (error) => {
              console.error('微信登录请求失败:', error);
              
              // 如果还可以重试，则延迟后重试
              if (retryCount < MAX_RETRIES) {
                console.log(`${RETRY_DELAY/1000}秒后进行第${retryCount+2}次尝试...`);
                setTimeout(() => {
                  tryLoginWithRetry(retryCount + 1);
                }, RETRY_DELAY);
              } else {
                console.error('登录失败: 已达到最大重试次数，尝试备用路径');
                // 尝试备用路径
                tryAlternativePath(resolve, reject);
              }
            }
          });
        }
        
        // 尝试备用路径
        function tryAlternativePath(resolve, reject) {
          // 使用配置中的备用路径列表
          const alternatePaths = authPaths.wxLoginAlternatives.map(path => config.getFullUrl(path));
          
          console.log('尝试备用登录路径');
          
          // 创建递归尝试函数
          function tryNext(index) {
            if (index >= alternatePaths.length) {
              // 所有路径都失败
              reject({
                code: 404,
                message: '所有登录API路径都失败，请检查网络连接后重试'
              });
              return;
            }
            
            const path = alternatePaths[index];
            console.log(`尝试备用路径 ${index+1}/${alternatePaths.length}:`, path);
            
            // 使用重试逻辑尝试备用路径
            tryAlternativeWithRetry(path, 0, index);
          }
          
          /**
           * 使用重试逻辑尝试备用路径
           * @param {string} path - 备用路径
           * @param {number} retryCount - 当前重试次数
           * @param {number} pathIndex - 当前路径索引
           */
          function tryAlternativeWithRetry(path, retryCount, pathIndex) {
            wx.request({
              url: path,
              method: 'POST',
              data: requestData,
              success: (res) => {
                console.log(`备用路径 ${path} 响应:`, res);
                
                if (res.statusCode === 200 && res.data.code === 200) {
                  console.log('找到有效的登录API路径:', path);
                  resolve(res.data.data);
                } 
                // 处理路径不存在的错误
                else if (res.statusCode === 404) {
                  // 当前路径失败，尝试下一个
                  tryNext(pathIndex + 1);
                }
                // 处理服务器暂时不可用的错误
                else if (res.statusCode === 503 || res.statusCode === 502 || res.statusCode === 500) {
                  if (retryCount < MAX_RETRIES) {
                    console.log(`备用路径服务器错误，${RETRY_DELAY/1000}秒后重试...`);
                    setTimeout(() => {
                      tryAlternativeWithRetry(path, retryCount + 1, pathIndex);
                    }, RETRY_DELAY);
                  } else {
                    // 当前路径失败，尝试下一个
                    tryNext(pathIndex + 1);
                  }
                }
                // 处理其他错误
                else {
                  if (retryCount < MAX_RETRIES) {
                    setTimeout(() => {
                      tryAlternativeWithRetry(path, retryCount + 1, pathIndex);
                    }, RETRY_DELAY);
                  } else {
                    // 当前路径失败，尝试下一个
                    tryNext(pathIndex + 1);
                  }
                }
              },
              fail: (error) => {
                console.error(`备用路径 ${path} 请求失败:`, error);
                
                // 如果还可以重试，则延迟后重试
                if (retryCount < MAX_RETRIES) {
                  setTimeout(() => {
                    tryAlternativeWithRetry(path, retryCount + 1, pathIndex);
                  }, RETRY_DELAY);
                } else {
                  // 尝试下一个路径
                  tryNext(pathIndex + 1);
                }
              }
            });
          }
          
          // 开始尝试第一个备用路径
          tryNext(0);
        }
      });
    },
    
    /**
     * 刷新Token
     * @param {string} refreshToken - 刷新令牌
     * @returns {Promise} - 新的令牌信息
     */
    refreshToken: (refreshToken) => {
      return new Promise((resolve, reject) => {
        // 添加重试逻辑
        function tryRefreshToken(retryCount) {
          wx.request({
            url: config.getFullUrl(authPaths.refreshToken),
            method: 'POST',
            data: {
              refreshToken
            },
            success: (res) => {
              if (res.data.code === 200) {
                resolve(res.data.data);
              } else if ((res.statusCode === 503 || res.statusCode === 502) && retryCount < MAX_RETRIES) {
                // 如果是服务器错误且未达到最大重试次数，则重试
                setTimeout(() => {
                  tryRefreshToken(retryCount + 1);
                }, RETRY_DELAY);
              } else {
                reject(res.data);
              }
            },
            fail: (error) => {
              if (retryCount < MAX_RETRIES) {
                setTimeout(() => {
                  tryRefreshToken(retryCount + 1);
                }, RETRY_DELAY);
              } else {
                reject(error);
              }
            }
          });
        }
        
        // 开始第一次尝试
        tryRefreshToken(0);
      });
    },
    
    /**
     * 退出登录
     * @param {string} token - 访问令牌
     * @returns {Promise} - 退出结果
     */
    logout: (token) => {
      return new Promise((resolve, reject) => {
        // 添加重试逻辑
        function tryLogout(retryCount) {
          wx.request({
            url: config.getFullUrl(authPaths.logout),
            method: 'POST',
            header: {
              'Authorization': `Bearer ${token}`
            },
            success: (res) => {
              if (res.data.code === 200) {
                resolve(res.data.data);
              } else if ((res.statusCode === 503 || res.statusCode === 502) && retryCount < MAX_RETRIES) {
                // 如果是服务器错误且未达到最大重试次数，则重试
                setTimeout(() => {
                  tryLogout(retryCount + 1);
                }, RETRY_DELAY);
              } else {
                reject(res.data);
              }
            },
            fail: (error) => {
              if (retryCount < MAX_RETRIES) {
                setTimeout(() => {
                  tryLogout(retryCount + 1);
                }, RETRY_DELAY);
              } else {
                reject(error);
              }
            }
          });
        }
        
        // 开始第一次尝试
        tryLogout(0);
      });
    }
  };
} 